{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os, glob, time, re, sys\n",
    "import numpy as np\n",
    "from scipy.optimize import curve_fit\n",
    "from scipy import stats, interpolate\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import warnings\n",
    "warnings.simplefilter(action='ignore', category=FutureWarning)\n",
    "plt.rcParams['figure.figsize'] = [4, 4]\n",
    "plt.rcParams['figure.dpi'] = 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Utility functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "correlation_names = {\n",
    "                     'Mean Equal time Green\\'s function:'     : 'cG'   ,\n",
    "                     'Up Equal time Green\\'s function:'       : 'cG_up', \n",
    "                     'Down Equal time Green\\'s function:'     : 'cG_dn', \n",
    "                     'Density-density correlation fn: (up-up)': 'cn_uu', \n",
    "                     'Density-density correlation fn: (up-dn)': 'cn_ud', \n",
    "                     'XX Spin correlation function:'          : 'cmx'  ,\n",
    "                     'ZZ Spin correlation function:'          : 'cmz'  ,\n",
    "                     'Average Spin correlation function:'     : 'cs'   ,\n",
    "                     'Pairing correlation function:'          : 'delta'\n",
    "                    }\n",
    "\n",
    "def parse_output(fname):\n",
    "    with open(fname, 'r') as f:\n",
    "        txt = f.readlines()\n",
    "\n",
    "    results = pd.Series(data={}, dtype=float)\n",
    "    \n",
    "    mode = 'Single Value'\n",
    "    for ii, _line in enumerate(txt):\n",
    "        if _line.strip() == '='*76:\n",
    "            mode = 'New Section'\n",
    "            continue\n",
    "\n",
    "        if mode == 'New Section':\n",
    "            mode = 'Correlation Values' if (_line.strip() in correlation_names.keys()) else 'Single Value'\n",
    "            if mode == 'Correlation Values': \n",
    "                c_name = correlation_names[_line.strip()]\n",
    "            continue\n",
    "\n",
    "        if mode == 'Single Value':\n",
    "            r = re.match('([\\w\\s\\S]*):([\\w\\s\\S]*)', _line)\n",
    "            if r != None:\n",
    "                val = r.group(2).split('+-')[0]\n",
    "                try:\n",
    "                    val = float(val)\n",
    "                except:\n",
    "                    val = val\n",
    "                results[r.group(1).strip()] = val\n",
    "\n",
    "        if mode == 'Correlation Values':\n",
    "            _pattern = 'point;dx=([\\d]*);dy=([\\d]*):([\\S\\w]*)'\n",
    "            r = re.match(_pattern, _line.replace(' ', ''))\n",
    "            if r != None:\n",
    "                ii = int(r.group(1))\n",
    "                jj = int(r.group(2))\n",
    "                _name = \"{}_{}{}\".format(c_name, ii, jj)\n",
    "                results[_name] = float(r.group(3).split('+-')[0])\n",
    "            continue\n",
    "    \n",
    "    return results\n",
    "\n",
    "def get_result(fnames):\n",
    "    df = pd.DataFrame()\n",
    "    for _f in fnames:\n",
    "        r = parse_output(_f)\n",
    "        df = df.append(r, ignore_index=True)\n",
    "    return df\n",
    "\n",
    "def get_cmat(df, d_max=4):\n",
    "    cmat_size = int(2*d_max+1)\n",
    "    cnn = np.zeros((cmat_size, cmat_size))\n",
    "    css = np.zeros((cmat_size, cmat_size))\n",
    "    for ii in range(cmat_size):\n",
    "        for jj in range(cmat_size):\n",
    "            _i, _j = sorted([np.abs(ii-d_max), np.abs(jj-d_max)])\n",
    "            _cuu = df['cn_uu_{}{}'.format(_j, _i)].values\n",
    "            _cud = df['cn_ud_{}{}'.format(_j, _i)].values\n",
    "            _s = df['Up spin occupancy']-df['Down spin occupancy']\n",
    "            _n = df['Density'].values\n",
    "            cnn[ii, jj] = 2.*(_cuu+_cud)-_n**2\n",
    "            css[ii, jj] = 2.*(_cuu-_cud)-_s**2\n",
    "    return cnn, css\n",
    "\n",
    "def find_closest_value(target_value, values):\n",
    "    _arg = np.argmin(np.abs(np.array(values)-target_value))\n",
    "    return values[_arg], _arg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load output files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_dir = 'run15_PaperData'\n",
    "# data_dir = 'run16_Repulsive'\n",
    "fnames = glob.glob(os.path.join(data_dir, '*.out'))\n",
    "df = get_result(fnames)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "U values: [0.0, -0.326531, -0.653061, -0.979592, -1.306122, -1.632653, -1.959184, -2.285714, -2.612245, -2.938776, -3.265306, -3.591837, -3.918367, -4.244898, -4.571429, -4.897959, -5.22449, -5.55102, -5.877551, -6.204082, -6.530612, -6.857143, -7.183673, -7.510204, -7.836735, -8.163265, -8.489796, -8.816327, -9.142857, -9.469388, -9.795918, -10.122449, -10.44898, -10.77551, -11.102041, -11.428571, -11.755102, -12.081633, -12.408163, -12.734694, -13.061224, -13.387755, -13.714286, -14.040816, -14.367347, -14.693878, -15.020408, -15.346939, -15.673469, -16.0]\n",
      "T values: [0.35000035 0.2999976  0.3999968 ]\n",
      "mu values: [-0.45, -0.4, -0.35, -0.3, -0.25, -0.2, -0.15, -0.1]\n"
     ]
    }
   ],
   "source": [
    "U_vals = sorted(df['U'].unique())[::-1]\n",
    "dtau_vals = df['dtau'].unique()\n",
    "L = df['Time slice - L'].unique()[0]\n",
    "T_vals = 1/(dtau_vals*L)\n",
    "mu_vals = sorted(df['mu_up'].unique())\n",
    "print('U values: {}'.format(U_vals))\n",
    "print('T values: {}'.format(T_vals))\n",
    "print('mu values: {}'.format(mu_vals))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Experiment Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "Us, css_sum, chi = [], [], []\n",
    "chi_ex = [[999, -999] for ii in range(len(U_vals))]\n",
    "css_sum_ex = [[999, -999] for ii in range(len(U_vals))]\n",
    "\n",
    "for ii, _T in enumerate([0.30, 0.35, 0.40]):\n",
    "    for jj, _n in enumerate([0.8, 0.85, 0.9]):\n",
    "        Us, css_sum, chi = [], [], []\n",
    "        \n",
    "        for kk, _U in enumerate(U_vals):\n",
    "            _T, _arg_T = find_closest_value(_T, T_vals)\n",
    "            _df = df[(df['U']==_U)&(df['dtau']==dtau_vals[_arg_T])]\n",
    "            _n, _arg_n = find_closest_value(_n, _df['Density'].values)\n",
    "            _df = _df[_df['Density']==_n]\n",
    "            # print(_df['mu_up'].values)\n",
    "\n",
    "            cnn, css = get_cmat(_df)\n",
    "            Us.append(-1*_U)\n",
    "            css_sum.append(np.sum(css))\n",
    "            chi.append(np.sum(css)/_T)\n",
    "            \n",
    "            if chi[-1]<chi_ex[kk][0]:\n",
    "                chi_ex[kk][0] = chi[-1]\n",
    "            if chi[-1]>chi_ex[kk][1]:\n",
    "                chi_ex[kk][1] = chi[-1]\n",
    "                \n",
    "            if css_sum[-1]<css_sum_ex[kk][0]:\n",
    "                css_sum_ex[kk][0] = css_sum[-1]\n",
    "            if css_sum[-1]>css_sum_ex[kk][1]:\n",
    "                css_sum_ex[kk][1] = css_sum[-1]\n",
    "                \n",
    "#         plt.plot(Us, css_sum, label='T={:.2f}, n={:.2f}'.format(_T, _n))\n",
    "# plt.xlabel('$\\\\left| U \\\\right|$')\n",
    "# plt.ylabel('$\\\\chi_s T$')\n",
    "# plt.legend()\n",
    "# plt.show()\n",
    "            \n",
    "chi_ex_vals = np.array(chi_ex).transpose()\n",
    "css_sum_ex_vals = np.array(css_sum_ex).transpose()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYwAAAENCAYAAAAc1VI3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3dd3yV9fn/8dd1zsnJJIyQQCZh7x2W1okDq4JaraJWUFvU1rZaF3Zavm21rdW2v9KqdWsVEbGlLlBxDyCsQAgjhBWGCSuMhIQk1++Pc7AxBMw4ue+T5Ho+Hjxy7vv+3PfnEkzeudfnI6qKMcYY83U8bhdgjDGmZbDAMMYYUy8WGMYYY+rFAsMYY0y9WGAYY4ypFwsMY4wx9eJoYIjIBBFZJyL5IjK9ju2ni8gyEakUkctrbcsQkQUikicia0Qk06m6jTHGOBgYIuIFZgIXAAOAySIyoFazrcBU4IU6DvEs8EdV7Q+MBoqar1pjjDG1+RzsazSQr6oFACIyC5gErDnWQFU3B7dV19wxGCw+VX072O7Q13XWuXNnzczMDFXtxhjTJixdunS3qibWtc3JwEgFttVYLgTG1HPfPsB+EZkLdAfeAaaralXNRiIyDZgGkJGRQXZ2dpOLNsaYtkREtpxom5P3MKSOdfUdl8QHnAbcCYwCehC4dPXVg6k+pqpZqpqVmFhnQBpjjGkkJwOjEEivsZwG7GjAvstVtUBVK4F/AyNCXJ8xxpiTcDIwlgC9RaS7iPiBq4B5Ddi3o4gcO204mxr3PowxxjQ/xwIjeGZwKzAfyANmq2quiMwQkYkAIjJKRAqBK4BHRSQ3uG8VgctR74rIKgKXt/7pVO3GGGNAWuvw5llZWWo3vY0xpmFEZKmqZtW1zd70NsYYUy8WGMYYY+rFAqOWktKjPPT2ejZ8cdDtUowxJqxYYNRSpcqjH2zkqU83u12KMcaEFQuMWjrF+rlgUDKvLttOSelRt8sxxpiwYYFRh8mj0yk7WsXLS7d9fWNjjGkjLDDq0K9rPANT4nnm081UVbfOx46NMaahLDBO4KIhKWzbV8Z7a20UdWOMAQuMExrbvRMJcX6etpvfxhgDWGCckM/r4ZuDkvk4fzf5RfaIrTHGWGCcxPkDuxLhFZ759ITDwxtjTJthgXES7aMjOK13Iq8sK+TAEXvE1hjTtllgfI2Lh6RQWlHFy9mFbpdijDGussD4Gr2S4uif3I5nP9tMtT1ia4xpwyww6uHiISls2VPKB+uL3S7FGGNcY4FRD+N6JJAQ6+epTza5XYoxxrjGAqMefF4PEwZ15cMNu9lYfMjtcowxxhWOBoaITBCRdSKSLyLT69h+uogsE5FKEbm8ju3xIrJdRP7mTMX/879HbDc73bUxxoQFxwJDRLzATOACYAAwWUQG1Gq2FZgKvHCCw/wf8EFz1XgyHWP8nNEnkdnZ29hzqNyNEowxxlVOnmGMBvJVtUBVK4BZwKSaDVR1s6rmANW1dxaRkUAXYIETxdblsuFplB+ttrMMY0yb5GRgpAI1xwsvDK77WiLiAf4E3PU17aaJSLaIZBcXh/6JpvROMYztkcAzn23hUHllyI9vjDHhzMnAkDrW1ffFhu8Db6jqSSeoUNXHVDVLVbMSExMbXGB9fGtEGiVlR5m1eGuzHN8YY8KVk4FRCKTXWE4DdtRz33HArSKyGXgQuE5EHghtefXTt2s7hqS1558fFVBRedyVM2OMabWcDIwlQG8R6S4ifuAqYF59dlTVa1Q1Q1UzgTuBZ1X1uKesnPKt4Wl8caCcf6/Y7lYJxhjjOMcCQ1UrgVuB+UAeMFtVc0VkhohMBBCRUSJSCFwBPCoiuU7V1xDDMzrQo3Msj7y/0YYLMca0GT4nO1PVN4A3aq37ZY3PSwhcqjrZMZ4Gnm6G8upNRLh8ZBp/mL+OBWu+YMKgrm6WY4wxjrA3vRvplJ6dSW4fxT/ez0fVzjKMMa2fBUYjeT3CpcNTWVlYwucFe90uxxhjmp0FRhOM79eFjjER/OP9fLdLMcaYZmeB0QR+n4eLh6bw4YbdrN5e4nY5xhjTrCwwmuibg5KJ8Xt55IONbpdijDHNygKjiWIjfVwwqCtvrNrJlj2H3S7HGGOajQVGCEwcmorXI/zzowK3SzHGmGZjgRECnWL9nNU3iZezCyk+aEOfG2NaJwuMELlseBoVldU8/alN42qMaZ0sMEIktWM0Y3sk8JwNfW6MaaUsMELo8pFpHDhSyYuLbOhzY0zrY4ERQn26BIY+f/xjG/rcGNP6WGCEmA19boxprSwwQuzY0OePfmBDnxtjWhcLjBATES4bkcbG4sO8k/eF2+UYY0zIWGA0g2/06kzX+Cge+WCjDX1ujGk1LDCagdcjXDIshWVb97Nk8z63yzHGmJBwNDBEZIKIrBORfBE5bk5uETldRJaJSKWIXF5j/TAR+UxEckUkR0SudLLuxhjfvwvto23oc2NM6+FYYIiIF5gJXAAMACaLyIBazbYCU4EXaq0vBa5T1YHABODPItKheStumqgILxcPSea9dcWs2Lbf7XKMMabJnDzDGA3kq2qBqlYAs4BJNRuo6mZVzQGqa61fr6obgp93AEVAojNlN97FQ1NoHx3B/W/k2b0MY0yL52RgpALbaiwXBtc1iIiMBvzAcRNQiMg0EckWkezi4uJGFxoqMX4fk0els2jTXt5bV+R2OcYY0yROBobUsa5Bv3aLSDLwHHC9qh73KrWqPqaqWaqalZgYHicg5w/sSkqHaO5/Yy1V9l6GMaYFczIwCoH0GstpwI767iwi8cDrwM9V9fMQ19ZsfF4P143txoaiQ7yytNDtcowxptGcDIwlQG8R6S4ifuAqYF59dgy2fxV4VlVfbsYam8UpPRPo26UdDy5YR1lFldvlGGNMozgWGKpaCdwKzAfygNmqmisiM0RkIoCIjBKRQuAK4FERyQ3u/m3gdGCqiKwI/hnmVO1NJSJcf2omRQfLefITmy/DGNMySWt9eicrK0uzs7MbtW9J6VG27i0NcUXwm9fXsHpHCR/edRYJcZEhP74xxjSViCxV1ay6ttmb3g6aMi6Tsooq/t9Ce5nPGNPyWGA4KL1TDOf278Lzi7awZc9ht8sxxpgGscBw2OTRGfhE+OP8dW6XYowxDWKB4bCEuEgmDUvltZyd5BTakCHGmJbDAsMFl41IpV2Uj4ffXu92KcYYU28WGC6I8fu4dHgq760rZtlWG/7cGNMyWGC45KLBgYEJ7SzDGNNSWGC4JNrv5VsjUvlow26WbN7rdjnGGPO1LDBcdMGgZDrGRPDQAjvLMMaEPwsMF0VFeLl8ZBqfFezh04273S7HGGNOygLDZRMGJpMQ6+eht9fbJEvGmLBmgeEyv8/DFVnpZG/ex8f5dpZhjAlfFhhh4LwBXUiMi+ShBXaWYYwJXxYYYSDC6+HbWeks37af99e7P7WsMcbUxQIjTJzTP4mu8VF2lmGMCVsWGGHC5/VwZVY6q7aXsGDNF26XY4wxx7HACCNn9UsirWM097+RR0VltdvlGGPMVzgaGCIyQUTWiUi+iEyvY/vpIrJMRCpF5PJa26aIyIbgnynOVe0cr0f47jd6sHlPKU/ZVK7GmDDjWGCIiBeYCVwADAAmi8iAWs22AlOBF2rt2wn4FTAGGA38SkQ6NnfNbhjZrSOjMjvy14UbKDp4xO1yjDHmS06eYYwG8lW1QFUrgFnApJoNVHWzquYAta/HnA+8rap7VXUf8DYwwYmi3fDdb/Sg/Gg1f3jLJlkyxoQPJwMjFdhWY7kwuC5k+4rINBHJFpHs4uKW+3hqSodoJg1LYc7SQlZss0mWjDHhwcnAkDrW1ff50Xrtq6qPqWqWqmYlJiY2qLhw8+2sdDrGRHDfvFyqq+0xW2OM+5wMjEIgvcZyGrDDgX1bpBi/j+vGZbJi237+vWK72+UYY4yjgbEE6C0i3UXED1wFzKvnvvOB80SkY/Bm93nBda3a2f2S6NMljgfeXMuh8kq3yzHGtHGOBYaqVgK3EvhBnwfMVtVcEZkhIhMBRGSUiBQCVwCPikhucN+9wP8RCJ0lwIzgulbNI8K003pSdLCcme/lu12OMaaNk9Y6DEVWVpZmZ2c3at+S0qNs3Vsa4ooa7+G31/NRfjFv334GmZ1j3S7HGNOKichSVc2qa5u96V2H99YVhdWb1teN64bXI8x4bY2NM2WMcY0FRi0biw9x++wV/OTlFRQUH3K7HAAS4iKZPCqDhWuLbJwpY4xrLDBq6ZkYx5NTR1FaXsUdL6/k5extVIXBY60Th6aQmRDDffNyOWw3wI0xLrDAqMNZfZNYcPvpnD+wK89+voV7X81hZ0mZqzX5vB5uObMXO0uO8Jd3N7haizGmbbLAOIGOsX7+dvVw/nLVMLbvK+NHs5bz1updrt5DGJAcz3kDuvDER5vI23nAtTqMMW2TBcZJiAiThqUy//bTGdmtIzPfz+eJj90dRXbKuEzionz8/NXV9ga4McZRFhj1kNw+muduGMPk0en8N2cHm3a7dzM8PjqCqadksnTrPmZnb/v6HYwxJkQsMOrJ4xGmT+hPfHQEj31Y4OqlqfH9khiYEs/9b65lz6Fy1+owxrQtFhgN0D4mgrvO78vqHQf4OH+3a3WICLec0ZND5ZXc/+Za1+owxrQtFhgNdNWoDAYkx/PUJ5s5crTKtTq6JcRyybBU5iwtZFHBHtfqMMa0HRYYDeT1CPdNHEjxoXJeWVboai1XjUonqV0kP3t1NeWV7oWXMaZtsMBohNHdO3Hx0BTmLtvOFwfcm0Y1KsLLzWf0JL/4EI+8X+BaHcaYtsECo5HuvaAfHg88+Ym7j9mOyuzE6b0787f3NpBfdNDVWowxrZsFRiOldIjm+2f24tONe8gpdHca1e+e1oMon5fpr6yydzOMMc3GAqMJpp3eg7SO0Tz2UYGr4011jPFzwze6k71lHy8s3upaHcaY1s0CowmiIrz8/ML+bNlTyuurdrpay/h+SQxNa8/9b+axq8S9+yrGmNbLAqOJzh/YlW/06swTHxfw5CebXHtaSUT4wVm9OFqp/PI/q12pwRjTujkaGCIyQUTWiUi+iEyvY3ukiLwU3L5IRDKD6yNE5BkRWSUieSJyr5N1n4yI8I9rR3DlqAxeXb6d215awdpd7gwMmNw+mqvHZLBgzRe8tdrdMx5jTOvztYEhIg+GoiMR8QIzgQuAAcBkERlQq9mNwD5V7QU8DPw+uP4KIFJVBwMjgZuOhUk4aBcVwf2XDea5G0dTVa3c80oOT32yyZVZ+y4ZlkqPzrH84t+5lJQddbx/Y0zrVZ8zjLND1NdoIF9VC1S1ApgFTKrVZhLwTPDzHGC8iAigQKyI+IBooAIIu/G9T+udyILbT+fKUenMXb6dH7+0nHW7nH3U1esRfnh2b/YcLucBGzbEGBNCTl6SSgVqDq9aGFxXZxtVrQRKgAQC4XEY2AlsBR5U1b21OxCRaSKSLSLZxcXFof8vqIfA2cYQnr0hcLYxfW4OGx2e6rVXUhwTh6by4uKtfOLimFfGmNalPoExVEQ2icg8EfmdiEwWkcEiEtHAvqSOdbWfRT1Rm9FAFZACdAfuEJEexzVUfUxVs1Q1KzExsYHlhdbpfRJ5/Uen0SnWz58WrHP8Zvg1YzJI6RDNXXNWcvCIXZoyxjRdfQIjBzgV+BuwBzgPeArYLSINeRynEEivsZwG7DhRm+Dlp/bAXuBq4C1VPaqqRcAnQFYD+nZFp1g/D14xlG37ynj2sy2O9h0V4eX28b3ZVXKE376e52jfxpjWqV6XpFR1h6ouUNU/qer1qpoFdAAubUBfS4DeItJdRPzAVcC8Wm3mAVOCny8HFmpg4omtwNkSEAuMBVrEBfrT+yQy9ZRM5q3cwfKt+xztu19yPJcOT2XWkm28t67I0b6NMa1PfQJjZl0rNWBDfTsK3pO4FZgP5AGzVTVXRGaIyMRgsyeABBHJB34CHHv0diYQB6wmEDxPqWpOfft22z0T+tEzMZa/vLvB8ctDV4/uRkanGO6Zk0NJqV2aMsY0njRm5jgROVtVF4pIMlCkqmE3tnZWVpZmZ2e7XcaXVm8v4ZKZnzC2RwJ3n9+XwMNfzsgvOsQdL6/gkmGpPHTlMMf6Nca0PCKyNHgV6TiNfUpqgoikAY8QeF/CfI1Bqe25/dw+fJy/mw/WO/sEV6+kOK7ICjzquyB3l6N9G2Naj8YGRgfgHuBuwAYuqqebTu/ByIyOPPLhRooOOvvXdmVWOj06x3Lv3FXsPVzhaN/GmNah3oERvFF9zAzgP6q6DnD+deYWyuf18PCVw1CFP7+zgepGXA5srAivh9vO6UNJ2VF+YWNNGWMaoSFnGJ+LyGAAVS1U1XeCn48bE8qcWEZCDPddPJBV20uYu2y7o3137xzLVaMzeD1nJ/9Z4WzfxpiWryGBcRPwLxG5s/YGEXkrdCW1fldkpXHh4GSeX7TF8aFDLh+RRv/kdvzs1dVs21vqaN/GmJat3oGhqkuAMcAIEVkoIt8XkUdFZFVDjmMCI9z+7rLBdI2P4sEF6zhcXulY316PcMe5fVGUH724nKNVdkXRGFM/DbmH8RsC70EMAXYBvwBigQmqel7zlNd6tY+O4K+Th1F8sJy/v59PYx5vbqwu8VH84MxeLN+2n7+8U+9XaYwxbVxDzgymAqNUdZCqXk0gONoBD4pIfHMU19qN7NaJ28/tzYcbdvNO3heO9n1a70TO6Z/EzPfy+WzjHkf7Nsa0TA0JjD41R4hV1WJVnQS8DywKdWFtxS1n9mJcjwQe+7CAbfucvacw7bSepHSI5raXlrPPHrU1xnyNhtzDqPOnmao+ClwcsoraGK9H+PNVw4jye/nj/HWOTroU7fdy53l92XOogrtfyXH0spgxpuUJyc1qVc0PxXHaqi7xUfzpiqFs2n2Ypz7d5GjfvZLimDIuk7fXfMHzi7Y62rcxpmWxp5vCxPj+Xbj+1Exey9nJZxudnfRo4rAURmR04DevrXH8MV9jTMthgRFGpl/QjyFp7Xno7fXkFzk3S59HhNvO6UO038ttLy13ZS5yY0z4s8AII5E+L49PyaJTnJ/fvL6G3YfKHeu7Y4yfH5zZi7ydB/nru/aorTHmeBYYYSapXRRPTh3FkcoqZry2hrIK50aOH9sjgbP7JfH39/Mdn+zJGBP+LDDCUL+u8cy8egRb9hzmjwvWUlXt3NNL007rQUJsJHfMXsmRo2E3zYkxxkWOBoaITBCRdSKSLyLHDVooIpEi8lJw+yIRyayxbYiIfCYiuSKySkSinKzdaWf2TeLXEweyZPM+nvzEuSenYiN9/Gh8bwp2H+b3b7WIWXCNMQ5xLDBExEtgqtULgAHAZBEZUKvZjcA+Ve1FYGKm3wf39QHPAzer6kDgTKDVzzf6nXGZ3HBqd+at3MHrOTsc63dYegcuHJzMU59s5lOHn9gyxoQvJ88wRgP5qlqgqhXALGBSrTaTgGeCn+cA4yUwl+l5QI6qrgRQ1T3hOC1sc/jZhf0Z3z+Jxz4qIHvz3q/fIUSmnpJJSvso7no5x/F5yI0x4cnJwEgFttVYLgyuq7ONqlYCJUAC0AdQEZkvIstE5O66OhCRaSKSLSLZxcXOToPaXLwe4a9XDad/cjy/n7+W9V84855EVISX287pw86SMn77ep4jfRpjwpuTgSF1rKt9N/dEbXzAN4Brgl8vFZHxxzVUfUxVs1Q1KzExsan1ho3YSB9PTR1F57hIZry2hh37yxzpt39yPJcOT2PWkm0sXOvs4IjGmPDjZGAUAuk1ltOA2hfmv2wTvG/RHtgbXP+Bqu4Ojmn1BjCi2SsOI0nxUTx7w2g8Ar+al+vYYIHXjMkgMyGGO1/OYWeJM0FljAlPTgbGEqC3iHQPzg9+FTCvVpt5wJTg58uBhRoYEW8+MEREYoJBcgawxqG6w0aPxDienDqKkrKj/Pq1XEormn/ipQivh7sn9KOsoorvP7/M3gI3pg1zLDCC9yRuJfDDPw+Yraq5IjJDRCYGmz0BJIhIPvATYHpw333AQwRCZwWwTFVfd6r2cDI8oyN/v2YEm3eXcv+bax2ZMS+9Yww/Ht+b5dv285vX21xOG2OCpLUOaZ2VlaXZ2dlul9FsXs7exl1zcjijTyI/ObcPHqnr9k9oPfFxAf9esYM/XzmMS4bXfl7BGNMaiMhSVc2qa5u96d1CXZGVzt0T+vLB+mKe+HiTI3NZTBmXycCUeO6du8pGtTWmDbLAaMFuOaMn15+aybyVO3jsowKqmzk0fF4Pd5/fj6gIDzc9l80Bez/DmDbFAqMFExF+edEAvndad17L2clf393Q7ONOdYr1c8+EfmzdW8pdL6+0WfqMaUMsMFo4EeGn3+zPbef05t21RTy4YF2z3wgfmNKe60/tzvzcL3j0w4Jm7csYEz58bhdgmk6CEyDF+n389o08yiuruGdCPyJ93mbrc9LQFNbuOsgf31rH6O6dGJHRsdn6MsaEBzvDaEW+d3oPfnvpILI372v2uTREhB+e1YuEOD+3zVrBofLmfyfEGOMuC4xW5pox3XjoyqHkbj/AL+atbtaBA2Mjffzk3D4U7itlxn9zm60fY0x4sMBohS4dnsbMa0ZQUHyIe19dxZ5mnOp1YEp7vjUijdnZhby5amez9WOMcZ8FRis1YVBXnrl+NMUHy7lnbk6zDlh49egMeifFMX3uKnaVHGm2fowx7rLAaMVO6dWZWdPGUlFZzT1zc9hYfKhZ+vF5Pdxxbl/Kj1Zxx+wVVDs4pawxxjkWGK3ckLQOzLnlFGL8Xn766ipWFe5vln5SO0bz3dN68MnGPY5OKWuMcY4FRhvQMzGOV245hdQO0fzqv7l8VrCnWfo5b0AXxnTvxO/fWsuaHQeapQ9jjHssMNqI5PbRzL5pHINS2vPAm3nMz90V8j5EhB+e3Zu4SB8/nrXckeHXjTHOscBoQzrG+vnX98ZwWu9E/vZePi8u3hryoT3aR0dw2zl92Fh8iFtfWE6lA8OvG2OcYYHRxsT4fTw+JYtvjUjjhcVbmfn+xpCPPzUioyPTTuvBwrVF/HJero03ZUwrYUODtEERXg8PXjGELvGR/P39jewvreCu8/uGdCiRC4ekUHyoghcWbSW1QzQ/OKtXyI5tjHGHnWG0USLC3RP68euJA1m8aS+/+E/o3wq/blw3zuiTyB/nr+PV5YUhPbYxxnmOBoaITBCRdSKSLyLT69geKSIvBbcvEpHMWtszROSQiNzpVM2t3ZRTMpl5zQjyiw5x9ys5FB0M3Yt3HhF+PL43Q9Lac9ecHD7J3x2yYxtjnOdYYIiIF5gJXAAMACaLyIBazW4E9qlqL+Bh4Pe1tj8MvNnctbY13xyczHM3jqGk7Cj3vJLDtr2lITt2hNfDvRf0J7VDNDc9t5S8nfa4rTEtlZNnGKOBfFUtUNUKYBYwqVabScAzwc9zgPEigcmqReQSoACwUe6awdgeCbw0bRwA0+fmsP6L0E3BGhfp41cXDSQqwsPUpxazs6T5hikxxjQfJwMjFdhWY7kwuK7ONqpaCZQACSISC9wD/PpkHYjINBHJFpHs4uLikBXeVgxIiWfOzacQHx3Bz/+9mpUhfCs8sV0kv7xoIAfKKrn5uaWUVzbf0OvGmObhZGBIHetqP295oja/Bh5W1ZMOhqSqj6lqlqpmJSYmNrLMti2zcyyv3HIKaR2j+fV/c/lsY+juO3TvHMvt5/RmZWEJ982zE0VjWhonA6MQSK+xnAbsOFEbEfEB7YG9wBjgDyKyGbgN+KmI3NrcBbdVXeKjePnm4Fvhb63l7TWheyt8XM/OXDEyjRcXb+PFxVtDdlxjTPNzMjCWAL1FpLuI+IGrgHm12swDpgQ/Xw4s1IDTVDVTVTOBPwO/U9W/OVV4W9Qhxs/z3x3DKT0789eF+byyrDBkL+BdM6YbwzM68Mv/rGbFtuYZDNEYE3qOBUbwnsStwHwgD5itqrkiMkNEJgabPUHgnkU+8BPguEdvjXNiI308MTWLC4ck8/Snm/nHB6F5K9zrEe48ty+dYv3c/PxSdjfjBE/GmNCR1jpsQ1ZWlmZnZ7tdRqtQXa38Yf46HvlgIyMzOnL3hL7E+Js+SMDG4kPcPSeHEd068PyNY/B57T1SY9wmIktVNauubfYdar6WxyNMv6Af9182mBXb9jN9bg7FB5t+VtAzMY4fnNWLzwv28sCba0NQqTGmOVlgmHqbPDqDp64fRdHBcu6as5L8oqbP4Hd2vyQuGpLM4x9vsuFDjAlzFhimQU7vk8jcW07F7/Nw76s5LN60t8nHvPHU7gxKjeeul3N4f11RCKo0xjQHCwzTYH27tuM/PziVXklx/PaNNU1+7Nbn9fDzbw6gW0IMNz+/lOzNTQ8hY0zoWWCYRkmKj2L2TeP4Rq/AY7dzljbtsdvYSB/3XTyQhNhIrn96iU3xakwYssAwjRaYjGkUE4em8Mxnm3nyk01UNyE0OsT4mTFpIJE+D9c9uYhNuw+HrlhjTJNZYJgm8fs8/PnKYUw9JZN/r9jBn99Z36RpWZPaRTFj0iCOVinXPr6IXSWhG27dGNM0FhimyTwe4VcXD+DO8/rw3rpifvtGHkeONn5wwfSOMdx38UD2lVZw7eOL2Hu4IoTVGmMaywLDhISIcOvZvfndpYNZtnUfv5zXtBn8eiXF8fNv9mfL3sNMfWoxh8orQ1itMaYxLDBMSF09JoOZVwdm8Js+d1WTXvAbnNaB6RP6sXp7Cd97JrtJZy3GmKazwDAhd8HgZJ69YQx7D1dw9ysr2dqEGfxGd0/g9nP68HnBHm59YRlHm3B/xBjTNBYYplmM65nA7JvGIQjTX8lp0tSsZ/ZN4qYzevJOXhF3z8mhOgQDIBpjGs4CwzSbASnxzP3+KSTE+fnFf1azeNOeRh/rwsHJfGdsN15dvp37/psbsqHWjTH1Z4FhmlV6pxheueUU+nZtx2/fyGvSW+FXjEzj0uGpPPvZFh56e30IqzTG1IcFhml2CXGRvPi9sV++FT5v5fZGHUdEuP6UTM4b0IX/tzCfxz7cGOJKjTEnY4FhHBEbGXgrfMLArvzzo028uXpno5DaOp0AABC/SURBVI4jInz/zF58o1dnfvfGWh5+e71dnjLGIRYYxjF+n4e/Th7O2f2S+Pv7G3kn74tGHcfrEe44tw/n9E/iL+9u4KevrmrS2+XGmPpxNDBEZIKIrBORfBE5bvpVEYkUkZeC2xeJSGZw/bkislREVgW/nu1k3SZ0/D4Pf79mBN/o1Zn/t3ADH6wvbtRxfF4PPzq7N9/OSufFxdu4+flllFXYexrGNCfHAkNEvMBM4AJgADBZRAbUanYjsE9VewEPA78Prt8NXKyqg4EpwHPOVG2aQ1SEl39el8WozE489PY6Pt24u1HHERG+M7YbN5/Rk3fzvuDaxxexv9SGETGmuTh5hjEayFfVAlWtAGYBk2q1mQQ8E/w8BxgvIqKqy1V1R3B9LhAlIpGOVG2aRbTfy5NTRzE8vSN/nL+uSRMxXTg4mXsm9CNn+34u/8dnbN9fFsJKjTHHOBkYqcC2GsuFwXV1tlHVSqAESKjV5lvAclU9bswJEZkmItkikl1c3LhLHcY5sZE+nrphFP2T43ngrTyWbtnX6GOd2qszMyYOYueBMi6d+YnNp2FMM3AyMKSOdbUfbzlpGxEZSOAy1U11daCqj6lqlqpmJSYmNrpQ45z4qAieu3E0vZPa8ZvX1/DRhsYH/aDU9jxw6RCqVbn8kU8bfX/EGFM3JwOjEEivsZwG7DhRGxHxAe2BvcHlNOBV4DpVtQfwW5EOMX5enDaW4Rkd+OP8dbyxqnGP3AJkdo7lwcuH0jU+ihueWsILi7aGsFJj2jYnA2MJ0FtEuouIH7gKmFerzTwCN7UBLgcWqqqKSAfgdeBeVf3EsYqNY9pHR/DcjWM4u38S//hgIy8u3tro9ysS4iK5/7LBDMvowE9fXcXv31pr408ZEwKOBUbwnsStwHwgD5itqrkiMkNEJgabPQEkiEg+8BPg2KO3twK9gF+IyIrgnySnajfOiIrw8si1I7lsRCovLN7KYx8VNHrK1xi/j19cOIAJA7vyj/c38qNZy214dGOaSFrrW7JZWVmanZ3tdhmmEaqrld+9kcfjH2/ijD6J/Hh8byK8jfvdRlWZu3w7T3+6maxuHXnkOyPpHGcP2BlzIiKyVFWz6tpmb3qbsOPxCD+7sD93T+jLB+uL+dW8XIoONG5ubxHhWyPSuPv8vqws3M/4P33AnKWFNpyIMY1ggWHC0rExo/50xVA2Fh/i1heX88aqnY2+RHVa70T+cuVwUjtEc+fLK7n28UVs3n04xFUb07rZJSkT9gr3lTL9lVV8nL+bwant+eHZvUhuH92oY1WrMj93F09/upmqauW2c/rw3dO6N/qSlzGtzckuSVlgmBZBVXlpyTZ+83oelVXVfGdcNy4akoJH6np15+vtOVTOox8W8FnBHvont+P+y4YwLL1DiKs2puWxwDCtxs6SMn46dxXvrSumf3I7pp3Wk15JcY0+3mcbd/PohwXsPVzBlaPSuXtCPzrF+kNYsTEtiwWGaVVUlbnLtvPbN/LYd7iCs/olcd3YbiQ08umn0opKXly8lXkrd9AuKoK7zu/L5NEZeD2NO3sxpiWzwDCt0oEjR5m5MJ8nP9mEV4RvjUzjkmGpREV4G3W8LXsO8+iHBazaXsKglHhmXDKIERkdQ1y1MeHNAsO0alv3lHL/m3m8uXoXneP8TBmXyRl9EpFG3N9QVT7asJsnP9nEnsMVTBqWwnXjujEio2OjjmdMS2OBYdqERQV7+L/X1rB6xwGGpXfgB2f2omv7qEYdq6yiipeyt/HGqp2UHa2iT5c4rh6dwaXD02gfExHiyo0JHxYYps2orlZeWLyV+9/Mo6pKuXZs4Gmqxt6PKKuo4sMNxczP3cWGokNE+jxcOCSZa8Zk2FmHaZUsMEybs7OkjJ/NXcXCdcX07dKOH57di24JsU06Zn7RIRas2cUH64sprahiUEo8U0/tzkVDkht938SYcGOBYdokVWXeyh3cNy+Xg0cq+XZWOpOGpRDj9zXpuGUVVby/vojXcnaydW8pnWL9XDsmg2vGdqNLfOMugRkTLiwwTJu251A5M15bw39W7MDnEQanticrsxOjMjs2+o1xCATSysIS/rtyB0s278XrES4YnMw5/ZMY2yPBwsO0SBYYxgBLt+xjfu4uFuYVkV98CIC0jtGMyuzEyIyO9E+Ox+9r3BAhO0vKeC1nJwvXFnGovBKA7p1jGdsjgbE9OlmAmBbDAsOYWrbsOczCtUW8m1fE55v2UFml+L0eBqbEMzS9A0PTOtAjMbbBQ49UVSubdh9m1fb9rNpeQu6OA5RWBObhyEyIYVzPzozt0YlxPRJIsgAxYcgCw5iTOFReyeJNe/h4wx4+zi9m/ReBs4/4KB+DUtvTPzmeAcnx9Ogci6+BgxSeLEB6dI5lbM8Ehqa1p1tCLN0SYujSLgqPvWFuXGSBYUwDFB04wqcb9/DRht0s2rSHwn1lAET6PPTuEkf/rvH07dqOlPbRJMVHEumr/xNSxwIkpzAQIGt2/i9AjvWR0SmGzM6xZCbE0C0hlu6dA2GS0j7awsQ0u7AJDBGZAPwF8AKPq+oDtbZHAs8CI4E9wJWqujm47V7gRqAK+JGqzj9ZXxYYJlS+OHCE7M37yN6yl+zN+1iz8wBVNeYIT4j10yU+ii7xkXSNjyKpXRSJ7SK//HOyodOrqpXiQ+Xs3F/GrgNH2LH/CDtLythVcoSdJUeoqKr+sq3f5yG9YzTdEmJJjIukczs/CbGRJMT5SYyLpFOcn3ZREcT6vcT4fY2+H2PatrAIDBHxAuuBc4FCYAkwWVXX1GjzfWCIqt4sIlcBl6rqlSIyAHgRGA2kAO8AfVT1hJM0W2CY5lJaUUnezoNs21vK1r2lX37dureUXQeOUPtbqlOMn87t/MT4fUR4Bb/XQ4TXQ4TPg9/rIdLnISrCS1RE4Gt0hJeoCC8RXuHI0Wr2lx5lX2kFe0sr2H2onD2HKjh45CglZUepPsm3b4RXiPH7iPV7iQ6GSLQ/cPzoCC8xfi9RNZa/3OYP1uLzEhnhIdLnJdIX+Or3efB6BJ9H8Ab/HPvsEcFzbL0IIny5XgAR7EXHFuBkgdG0B9IbZjSQr6oFwaJmAZOANTXaTALuC36eA/xNAv+HTQJmqWo5sElE8oPH+8yh2o35Uozfx8huHRnZ7fiBCSsqq9lVcoTt+8vYvr+MHfvL2L6vjB0lZRwur6S0oop9lUcpP1pFeWV18E8VR45W19FTwxz7oXxMZZVyoOwoB8qOnnCfcLkgfVyMyPHrpFZLrVG91NGy4Z3WX7jHXkKcn0U/PSfkx3UyMFKBbTWWC4ExJ2qjqpUiUgIkBNd/Xmvf1NodiMg0YBpARkZGyAo3pr78Pg8ZCTFkJMQ0aL+qaqW0IhAox4KltKKKispqKqoCX8srq4PL1VRWKUerqqmsViqrqjkaXD4RBVQDP2RVA++QqEKVKtXVSmV14BgVldVUVCoVVVVUK1RVV1NVrcF2gTr/d4xjP7QlMHWuBmY0DPSl/+tT+XLdsVqosXxcrXW0P9aX1PhR/bUnKydJQ621pDU3nOy4+tV9v655U9U8dkPCPaVD498vOhknA6Ouv9fafwcnalOffVHVx4DHIHBJqqEFGuMWr0doFxVBuygb2NCELyfvihUC6TWW04AdJ2ojIj6gPbC3nvsaY4xpRk4GxhKgt4h0FxE/cBUwr1abecCU4OfLgYUaOC+dB1wlIpEi0h3oDSx2qG5jjDE4eEkqeE/iVmA+gcdqn1TVXBGZAWSr6jzgCeC54E3tvQRChWC72QRukFcCPzjZE1LGGGNCz17cM8YY86WTPVZrb/YYY4ypFwsMY4wx9WKBYYwxpl4sMIwxxtRLq73pLSLFwJYmHKIzsDtE5YSS1dUwVlfDWF0N0xrr6qaqiXVtaLWB0VQikn2iJwXcZHU1jNXVMFZXw7S1uuySlDHGmHqxwDDGGFMvFhgn9pjbBZyA1dUwVlfDWF0N06bqsnsYxhhj6sXOMIwxxtSLBYYxxph6scCoRUQmiMg6EckXkelu1wMgIuki8p6I5IlIroj82O2aahIRr4gsF5HX3K7lGBHpICJzRGRt8O9tnNs1AYjI7cF/w9Ui8qKIRLlYy5MiUiQiq2us6yQib4vIhuDX4+ehdaeuPwb/LXNE5FUR6RAOddXYdqeIqIh0Dpe6ROSHwZ9luSLyh1D0ZYFRg4h4gZnABcAAYLKIDHC3KiAwpPsdqtofGAv8IEzqOubHQJ7bRdTyF+AtVe0HDCUM6hORVOBHQJaqDiIwzP9VLpb0NDCh1rrpwLuq2ht4N7jstKc5vq63gUGqOgRYD9zrdFHUXRcikg6cC2x1uqCgp6lVl4icBUwChqjqQODBUHRkgfFVo4F8VS1Q1QpgFoG/dFep6k5VXRb8fJDAD7/j5jR3g4ikARcCj7tdyzEiEg+cTmB+FVS1QlX3u1vVl3xAdHBGyRhcnDlSVT8kMO9MTZOAZ4KfnwEucbQo6q5LVReoamVw8XMCs266XlfQw8DdNGza7ZA5QV23AA+oanmwTVEo+rLA+KpUYFuN5ULC5AfzMSKSCQwHFrlbyZf+TOCbpdrtQmroARQDTwUvlT0uIrFuF6Wq2wn8prcV2AmUqOoCd6s6ThdV3QmBX1SAJJfrqcsNwJtuFwEgIhOB7aq60u1aaukDnCYii0TkAxEZFYqDWmB8ldSxLmyeOxaROOAV4DZVPRAG9VwEFKnqUrdrqcUHjAD+oarDgcO4c2nlK4L3AyYB3YEUIFZErnW3qpZFRH5G4BLtv8KglhjgZ8Av3a6lDj6gI4FL2HcBs0Wkrp9vDWKB8VWFQHqN5TRcvGRQk4hEEAiLf6nqXLfrCToVmCgimwlcvjtbRJ53tyQg8O9YqKrHzsLmEAgQt50DbFLVYlU9CswFTnG5ptq+EJFkgODXkFzKCAURmQJcBFyj4fECWU8C4b8y+D2QBiwTka6uVhVQCMzVgMUErgA0+Ya8BcZXLQF6i0h3EfETuCE5z+WaCP5m8ASQp6oPuV3PMap6r6qmqWomgb+rharq+m/MqroL2CYifYOrxhOYD95tW4GxIhIT/DcdTxjcjK9lHjAl+HkK8B8Xa/mSiEwA7gEmqmqp2/UAqOoqVU1S1czg90AhMCL4/5/b/g2cDSAifQA/IRhV1wKjhuBNtVuB+QS+kWeraq67VQGB3+S/Q+A3+BXBP990u6gw90PgXyKSAwwDfudyPQTPeOYAy4BVBL7/XBtaQkReBD4D+opIoYjcCDwAnCsiGwg8+fNAmNT1N6Ad8Hbw//9HwqQu152grieBHsFHbWcBU0JxVmZDgxhjjKkXO8MwxhhTLxYYxhhj6sUCwxhjTL1YYBhjjKkXCwxjjDH1YoFhjDGmXiwwjDHG1IsFhjHNSETeDw4YeWxOhztrbBMR2R988/vLdsaEKwsMY5wzCMipsdwdKA6XoS6M+ToWGMY4ZzBfDYwhtZaNCWsWGMY4IDi0ub/WwHQWGKZFscAwxhm1zy7AAsO0MBYYxjijL7Dx2IKIeAiMQvyRaxUZ00AWGMY4YwswSkSigss/BT5U1SbPUWCMU3xuF2BMW6CqC0TkfGCtiJQDnwM3u1yWMQ1igWGMQ1T1DuAOt+swprHskpQxxph6scAwpnk9DewPYTtjXGNTtBpjjKkXO8MwxhhTLxYYxhhj6sUCwxhjTL1YYBhjjKkXCwxjjDH1YoFhjDGmXv4/TpVEkOpsOp4AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(Us, css_sum_ex_vals[0], 'C0')\n",
    "plt.plot(Us, css_sum_ex_vals[1], 'C0')\n",
    "plt.fill_between(Us, *css_sum_ex_vals, alpha=0.2)\n",
    "plt.xlabel('$\\\\left| U \\\\right|$')\n",
    "plt.ylabel('$\\\\chi_s T$')\n",
    "# plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.DataFrame(np.array([Us, chi_ex_vals[0], chi_ex_vals[1]])).to_csv(\"chi_vs_U_4.csv\")\n",
    "pd.DataFrame(np.array([Us, css_sum_ex_vals[0], css_sum_ex_vals[1]])).to_csv(\"SpinFluc_vs_U_4.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Output DataFrame to CSV"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.to_csv('sim1_PaperPrameters.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
